
import tools from './tools'
/**
 * 
 * array (Array): 需要处理的数组
 * [size=1] (number): 每个数组区块的长度 
 * 将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。
 */
function chunk(array,number) {
    let index = 0;
    let newArray = []//首先创建一个新的空数组。用来存放分割好的数组
    while(index < array.length) {
        newArray.push(array.slice(index, index += number));
    }
    return newArray
}
/**
 * 
 * array (Array): 需要处理的数组
 * 过滤掉数组中的假值
 */
function compact(array) {
    return array.filter(Boolean)
}

//扁平化数组的方法
/**
 * 
 * array (Array): 需要处理的数组
 * n 扁平化的维度
 */
function flat(arr,n) {
    let times = 0; //利用闭包记住times
    // 遍历数组
    function flatten(arr) {
      const result = [];
      arr.forEach(item => {
        if (Array.isArray(item)) {
          // 如果元素是数组则再次进行flatten操作且times+1
          if (times > n) {
           //递归次数用尽，直接把元素推入数组
            result.push(item);
          }
          times++;
          result.push(...flatten(item));
        } else {
          result.push(item);
        }
      });
      return result;
    }
    return flatten(arr);
}
// 方法2
// 使用reduce 和 concat 会大大降低代码量，不过核心还是要靠递归
function flatUseRC(arr,dep=1) {
    return arr.reduce((acc, cur) => {
      return acc.concat(Array.isArray(cur)&&dep>0 ? flat(cur,dep-1):[cur]) 
    },[])
}  

//创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中
function difference(array, diff = []){
  //判断传入的两个数组是否有效
  if (!diff.length || !array.length) return [...array];
  //includes 两个数组之间 存在返回true
  return array.filter((val) => !diff.includes(val));
};

// 创建一个数组切片 切掉数组前n个
function drop(arr,n) {
  
}

// 对象数组
// 对象根据某属性去重
function duplicateRemoval(data, field) {
  var fields = [];
  var arr = [];
  for (var i = 0; i < data.length; i++) {
      if (fields.indexOf(data[i][field]) == -1) {
          fields.push(data[i][field]);
          arr.push(data[i]);
      }
  }
  return arr;
}

//对象根据某属性排序
function MsgSort(arr,name) {
  arr.sort((a, b) => {
      let t1 = new Date(a[name])
      let t2 = new Date(b[name])
      return t1.getTime() - t2.getTime()
  })
  return arr
}
//对象根据某属性排序2 compare(比较)
function compare(attr, rev) {
  // console.log(attr, rev)
  if (rev == undefined) {
    rev = 1;
  } else {
    rev = rev ? 1 : -1;
  }
  return (a, b) => {
    a = a[attr];
    b = b[attr];
    if (a > b) {
      return rev * -1;
    }
    if (a < b) {
      return rev * 1;
    }
    return 0;
  };
}
const rayllei = {
    chunk,//切割数组
    compact,//过滤掉数组中的假值
    flat,//扁平化数组
    flatUseRC,
    difference,//过滤掉不同于当前数组
    // 对象数组
    duplicateRemoval,//对象根据某属性去重
    MsgSort,//对象根据某属性排序
    compare,//对象根据某属性排序2
}

export default rayllei;

